designer/server/src/main/scala/pl/touk/nussknacker/ui/api/ScenarioActivityApiHttpService.scala (3)

28-28: LGTM! Good architectural improvement.

The change to use FetchScenarioActivityService instead of DeploymentManagerDispatcher improves separation of concerns and follows the Single Responsibility Principle.

Also applies to: 42-42

---

Line range hint 246-262: Consider moving filtering logic to service layer.

The current implementation mixes concerns by having the HTTP service handle complex filtering logic. Consider moving this logic to FetchScenarioActivityService to:

• Keep the HTTP service focused on request/response handling
• Make the filtering logic reusable
• Improve testability

def fetchActivities(
  processIdWithName: ProcessIdWithName
)(implicit loggedUser: LoggedUser): EitherT[Future, ScenarioActivityError, List[Dtos.ScenarioActivity]] = {
  EitherT.right {
    for {
-     combinedActivities <- fetchScenarioActivityService.fetchActivities(processIdWithName, after = None)
-     combinedSuccessfulActivities = combinedActivities.filter {
-       case _: BatchDeploymentRelatedActivity => true
-       case activity: DeploymentRelatedActivity =>
-         activity.result match {
-           case _: DeploymentResult.Success => true
-           case _: DeploymentResult.Failure => false
-         }
-       case _ => true
-     }
-     sortedResult = combinedSuccessfulActivities.map(toDto).toList.sortBy(_.date)
+     activities <- fetchScenarioActivityService.fetchFilteredActivities(processIdWithName, after = None)
+     sortedResult = activities.map(toDto).toList.sortBy(_.date)
    } yield sortedResult
  }
}

---

247-249: Plan to add API filtering support.

The comment indicates that API filtering support is pending. This should be tracked and implemented to provide better control over the returned activities.

Would you like me to create a GitHub issue to track the implementation of API filtering support?

Configuration used: CodeRabbit UI
Review profile: CHILL

-      allActivities <- fetchScenarioActivityService.fetchActivities(processName, Some(limit))(user).value.map {
-        case Right(activities) => activities
-        case Left(_)           => List.empty
-      }
+      allActivities <- fetchScenarioActivityService.fetchActivities(processName, Some(limit))(user).value.map {
+        case Right(activities) => activities
+        case Left(error) =>
+          logger.warn(s"Failed to fetch activities for scenario $processName: $error")
+          List.empty
+      }

#!/bin/bash
# Find all implementations of NotificationService to ensure they're updated
ast-grep --pattern 'class $_ extends NotificationService'

#!/bin/bash
# Let's try a different pattern to find implementations, including trait mixing
rg "extends.*NotificationService|with.*NotificationService" -l

#!/bin/bash
# Also search for class definitions that might implement NotificationService
rg "class.*NotificationServiceImpl" -l

#!/bin/bash
# Let's check the actual implementation file content
rg "class.*NotificationServiceImpl" -A 10

#!/bin/bash
# Let's also check if there are any tests that might show implementations
rg "NotificationService" ".*[Tt]est.*\.scala$"

#!/bin/bash
# Let's fix the test search by looking in all files
rg "NotificationService.*Test|Test.*NotificationService" --type scala

#!/bin/bash
# Let's also check if this is the only implementation by looking at the full content of NotificationService.scala
cat designer/server/src/main/scala/pl/touk/nussknacker/ui/notifications/NotificationService.scala